import { getUUID } from '@/assets/utils'
/**
 * 获取单元格
 * @param arr 二维数组
 * @param x
 * @param n
 * @returns
 */
export const getRowCells = (arr: any[][], x: number, y: number, n: number) => {
  const siteArr = arr[x].map((el, i) => {
    return {
      ...el,
      x,
      y: i
    }
  })
  return siteArr.slice(y, y + n)
}

/**
 * 获取单元格
 * @param arr 二维数组
 * @param y
 * @param n
 * @returns
 */
export const getColCells = (arr: any[][], x: number, y: number, n: number) => {
  // 转置二维数组
  const arrT = transpose(arr)
  const siteArr = arrT[y].map((el, i) => {
    return {
      ...el,
      x: i,
      y
    }
  })
  return siteArr.slice(x, x + n)
}

/**
 * 向前新增一行
 * @param arr 二维数组
 * @param x
 * @param y
 * @returns
 */
export const addRowPrev = (arr: any[][], x: number) => {
  const newRow = []
  for (let index = 0; index < arr[x].length; index++) {
    newRow.push({
      id: 'td-' + getUUID(),
      w: 1,
      h: 1
    })
  }
  arr.splice(x, 0, newRow)
  return arr
}

/**
 * 向后新增一行
 * @param arr 二维数组
 * @param x
 * @param y
 * @returns
 */
export const addRowNext = (arr: any[][], x: number) => {
  const newRow = []
  for (let index = 0; index < arr[x].length; index++) {
    newRow.push({
      id: 'td-' + getUUID(),
      w: 1,
      h: 1
    })
  }
  arr.splice(x + 1, 0, newRow)
  return arr
}

/**
 * 向前新增一列
 * @param arr 二维数组
 * @param x
 * @param y
 * @returns
 */
export const addColPrev = (arr: any[][], y: number) => {
  // 转置二维数组
  const arrT = transpose(arr)
  const newRow = []
  for (let index = 0; index < arrT[y].length; index++) {
    newRow.push({
      id: 'td-' + getUUID(),
      w: 1,
      h: 1
    })
  }
  arrT.splice(y, 0, newRow)
  return transpose(arrT)
}

/**
 * 向后新增一列
 * @param arr
 * @param x
 * @param y
 * @returns
 */
export const addColNext = (arr: any[][], y: number) => {
  // 转置二维数组
  const arrT = transpose(arr)
  const newRow = []
  for (let index = 0; index < arrT[y].length; index++) {
    newRow.push({
      id: 'td-' + getUUID(),
      w: 1,
      h: 1
    })
  }
  arrT.splice(y + 1, 0, newRow)
  return transpose(arrT)
}

/**
 * 移除列
 * @param arr
 * @param y
 * @returns
 */
export const removeCol = (arr: any[][], y: number) => {
  // 转置二维数组
  const arrT = transpose(arr)
  arrT.splice(y, 1)
  return transpose(arrT)
}

/**
 * 移除行
 * @param arr
 * @param x
 * @returns
 */
export const removeRow = (arr: any[][], x: number) => {
  arr.splice(x, 1)
  return arr
}

/**
 * 同行X跨列y 合并行单元格
 * @param arr 二维数组
 * @param x 行数
 * @param y 列数
 * @param n 要合并的单元格数
 */
export const mergeColCell = (arr: any[][], x: number, y: number, n: number) => {
  // 待合并元素宽度值为零
  for (let index = y + 1; index < y + n; index++) {
    arr[x][index].w = 0
  }
  // 合并元素
  arr[x][y].w = n
  return arr
}

/**
 * 解除跨列合并单元格
 * @param arr 二维数组
 * @param x
 * @param y
 */
export const cancelMergeCol = (arr: any[][], x: number, y: number) => {
  const obj = arr[x][y]
  for (let index = y + 1; index < y + obj.w; index++) {
    arr[x][index].w = 1
  }
  // 合并元素
  arr[x][y].w = 1
  return arr
}

/**
 * 同列Y跨行X 合并列单元格
 * @param arr 二维数组
 * @param x 行数
 * @param y 列数
 * @param n 要合并的单元格数
 */
export const mergeRowCell = (arr: any[][], x: number, y: number, n: number) => {
  // 转置二维数组
  const arrT = transpose(arr)
  for (let index = x + 1; index < x + n; index++) {
    arrT[y][index].h = 0
  }
  // 合并元素
  arrT[y][x].h = n
  return transpose(arrT)
}

/**
 * 解除跨行合并单元格
 * @param arr 二维数组
 * @param x
 * @param y
 */
export const cancelMergeRow = (arr: any[][], x: number, y: number) => {
  // 转置二维数组
  const arrT = transpose(arr)
  const obj = arrT[y][x]
  for (let index = x + 1; index < x + obj.h; index++) {
    arrT[y][index].h = 1
  }
  // 合并元素
  arrT[y][x].h = 1
  return transpose(arrT)
}

/**
 * 创建二维数组
 * @param rows 行数
 * @param cols 列数
 * @param defaultValue 默认值
 */
export const create2DArray = (
  rows: number,
  cols: number,
  defaultValue: { w: number; h: number }
): any[][] => {
  const result: any = []
  for (let i = 0; i < rows; i++) {
    const arr: any = []
    result.push(arr)
    for (let j = 0; j < cols; j++) {
      result[i].push({
        id: 'td-' + getUUID(),
        ...defaultValue
      })
    }
  }
  return result
}
/**
 * 转置二维数组
 * @param matrix 二维数组
 */
export const transpose = <T>(matrix: T[][]): T[][] => {
  if (!matrix.length || !matrix[0].length) {
    // 传入二维数据不能为空
    throw new Error('Input matrix should not be empty')
  }

  const rows = matrix.length
  const cols = matrix[0].length
  const transposed: T[][] = new Array(cols)

  for (let i = 0; i < cols; i++) {
    transposed[i] = new Array(rows)
    for (let j = 0; j < rows; j++) {
      transposed[i][j] = matrix[j][i]
    }
  }

  return transposed
}
